Working with Abstract Base Classes and Interfaces in Python

Course: Python Training

Topic: Working with Abstract Base Classes and Interfaces

Course Link: Python Training Course

Demo Link: Register for a Free Course Demo

Website: JustAcademy

1. Introduction to Abstract Base Classes and Interfaces

In Python, abstract base classes and interfaces help developers define common structures and expected behaviors for related classes. They are useful when multiple classes need to provide the same methods but implement those methods differently.

For example, a payment application may support credit cards, UPI, and digital wallets. Each payment method processes payments differently, but every payment class should provide a method such as pay(). An abstract base class can define this requirement and ensure that subclasses implement it.

Python does not have a separate interface keyword like Java. Instead, interfaces can be represented through abstract base classes, protocols, or other conventions.

Learning Objectives

• Understand abstraction and its role in object-oriented programming.
• Learn the meaning and purpose of abstract base classes.
• Use the abc module and the ABC class.
• Declare abstract methods using @abstractmethod.
• Understand how Python represents interface-like behavior.
• Implement abstract classes in real-world applications.
• Identify common mistakes and follow best practices.

2. What Is Abstraction in Python?

Abstraction is an object-oriented programming principle that hides unnecessary implementation details and exposes only the essential functionality required by the user.

Consider driving a car. A driver uses the steering wheel, accelerator, and brakes without needing to understand every internal mechanism of the engine. The interface presents the operations the user needs while hiding the implementation details.

Example Without Abstraction

class CreditCardPayment:
    def pay(self, amount):
        print(f"Processing credit card payment of ₹{amount}")


class UPIPayment:
    def pay(self, amount):
        print(f"Processing UPI payment of ₹{amount}")


credit_card = CreditCardPayment()
upi = UPIPayment()

credit_card.pay(1000)
upi.pay(500)

Both classes provide a pay() method, but nothing explicitly requires every new payment class to implement it. A developer could accidentally create a payment class without the required method.

Abstract base classes provide a mechanism for defining and enforcing such requirements.

Benefits of Abstraction

• Reduced complexity: Users interact with essential operations rather than internal implementation details.
• Consistency: Related classes follow a common structure.
• Maintainability: Implementations can change without changing the expected method contract.
• Extensibility: New implementations can be added more easily.
• Reliability: Abstract methods help detect incomplete subclasses when objects are instantiated.

3. What Is an Abstract Base Class?

An Abstract Base Class (ABC) is a class designed primarily to serve as a base for other classes. It can define abstract methods that subclasses must implement before they can be instantiated.

Python provides the abc module for creating abstract base classes. The ABC class is commonly used as the parent class, while the @abstractmethod decorator marks methods that subclasses are required to implement.

Basic Syntax

from abc import ABC, abstractmethod

class Shape(ABC):

    @abstractmethod
    def area(self):
        pass

In this example:

• ABC provides the foundation for the abstract base class.
• @abstractmethod marks area() as an abstract method.
• pass indicates that the method has no implementation in this example.
• A concrete subclass must implement area() before it can be instantiated.

Although an abstract class may contain concrete methods and attributes, it cannot be instantiated while it still has unresolved abstract methods.

4. Understanding the ABC Module

The abc module stands for Abstract Base Classes. It is included in Python's standard library and provides tools for defining abstract classes and methods.

For most everyday use cases, inheriting from ABC and using @abstractmethod is sufficient. The other features are useful for more advanced class designs.

5. Creating Your First Abstract Base Class

Let's create a simple abstract class named Animal. Every animal subclass must provide its own implementation of the make_sound() method.

Example

from abc import ABC, abstractmethod

class Animal(ABC):

    @abstractmethod
    def make_sound(self):
        pass


class Dog(Animal):

    def make_sound(self):
        return "Woof!"


class Cat(Animal):

    def make_sound(self):
        return "Meow!"


dog = Dog()
cat = Cat()

print(dog.make_sound())
print(cat.make_sound())

Output

Woof!
Meow!

Explanation

1. Animal inherits from ABC.
2. The make_sound() method is declared abstract.
3. Dog inherits from Animal and implements the required method.
4. Cat also implements the method with different behavior.
5. Both concrete classes can be instantiated and used independently.

This approach guarantees that a concrete subclass cannot be instantiated until all inherited abstract methods have been implemented.

6. Understanding Abstract Methods

An abstract method defines an operation that concrete subclasses are expected to provide. It is declared with the @abstractmethod decorator.

Example

from abc import ABC, abstractmethod

class Employee(ABC):

    @abstractmethod
    def calculate_salary(self):
        pass


class FullTimeEmployee(Employee):

    def calculate_salary(self):
        return 50000


class PartTimeEmployee(Employee):

    def calculate_salary(self):
        return 20000


full_time = FullTimeEmployee()
part_time = PartTimeEmployee()

print(full_time.calculate_salary())
print(part_time.calculate_salary())

Output

50000
20000

The abstract method establishes a common contract, while each subclass supplies its own implementation.

Important Points

• Abstract methods can have parameters and return values.
• Concrete subclasses must implement all inherited abstract methods before instantiation.
• An abstract method may contain an implementation; subclasses can override it and may call it using super().
• Python checks abstract-method requirements when a class is instantiated, not by performing a full static type check.

7. Can Abstract Classes Contain Concrete Methods?

Yes. An abstract base class can contain both abstract methods and regular methods. Concrete methods allow the base class to share common behavior among subclasses.

Example

from abc import ABC, abstractmethod

class BankAccount(ABC):

    def __init__(self, balance):
        self.balance = balance

    @abstractmethod
    def calculate_interest(self):
        pass

    def display_balance(self):
        return f"Balance: ₹{self.balance}"


class SavingsAccount(BankAccount):

    def calculate_interest(self):
        return self.balance * 0.04


account = SavingsAccount(10000)

print(account.display_balance())
print(account.calculate_interest())

Output

Balance: ₹10000
400.0

Explanation

The BankAccount class provides a constructor and a reusable display_balance() method. However, it requires each concrete account type to define its own interest calculation.

The subclass inherits the common behavior and implements the specialized operation. This avoids unnecessary duplication.

8. What Is an Interface in Python?

An interface describes a set of operations that a class should provide. It focuses on what an object can do rather than how those operations are implemented.

Python does not have a dedicated interface keyword. Interface-like behavior can be created in several ways:

• Abstract base classes: Define required methods and optionally shared behavior.
• Structural typing with Protocol: Describes the methods and attributes an object should have without requiring it to inherit from a specific base class.
• Duck typing: Allows an object to be used when it supports the required operations, regardless of its inheritance hierarchy.

Example of an Interface-Like Abstract Base Class

from abc import ABC, abstractmethod

class NotificationService(ABC):

    @abstractmethod
    def send(self, message):
        pass


class EmailNotification(NotificationService):

    def send(self, message):
        print(f"Sending email: {message}")


class SMSNotification(NotificationService):

    def send(self, message):
        print(f"Sending SMS: {message}")


def notify_user(service, message):
    service.send(message)


email = EmailNotification()
sms = SMSNotification()

notify_user(email, "Your order has shipped.")
notify_user(sms, "Your OTP is 123456.")

Output

Sending email: Your order has shipped.
Sending SMS: Your OTP is 123456.

The NotificationService class defines the required operation. Email and SMS notifications implement that operation differently, while the notify_user() function works with either implementation.

9. Using Protocol to Define Interfaces

Python's Protocol class, available from the typing module, supports structural typing. A class does not need to inherit from the protocol to satisfy its requirements.

This is useful when you want to describe an interface without forcing classes into a shared inheritance hierarchy.

Example

from typing import Protocol

class Drawable(Protocol):

    def draw(self) -> str:
        ...


class Circle:

    def draw(self) -> str:
        return "Drawing a circle"


class Rectangle:

    def draw(self) -> str:
        return "Drawing a rectangle"


def render_shape(shape: Drawable):
    print(shape.draw())


render_shape(Circle())
render_shape(Rectangle())

Output

Drawing a circle
Drawing a rectangle

How It Works

• Drawable describes the required draw() method.
• Circle and Rectangle do not inherit from Drawable.
• Both classes satisfy the protocol because they provide a compatible draw() method.
• A static type checker can verify whether an object satisfies the protocol's requirements.

By default, protocols are mainly used for static structural typing. Runtime checks using isinstance() require a protocol decorated with @runtime_checkable, and those checks generally verify member presence rather than full method signatures.

10. Abstract Base Classes vs. Interfaces

Abstract base classes and interfaces are closely related concepts, but they emphasize different design goals. In Python, an abstract base class can also act as an interface when it defines required operations without providing much implementation.

Choose the approach that best fits the design. Use an ABC when explicit inheritance and shared behavior are useful. Use a protocol when you want to accept any object with the required structure.

11. Preventing Instantiation of Abstract Classes

A class that still has abstract methods cannot be instantiated. Python raises a TypeError if you try to create an instance before implementing all required abstract methods.

Example

from abc import ABC, abstractmethod

class Payment(ABC):

    @abstractmethod
    def process_payment(self, amount):
        pass


class CashPayment(Payment):
    pass


payment = CashPayment()

Expected Error

TypeError: Can't instantiate abstract class CashPayment
with abstract method process_payment

The exact wording of the error may vary by Python version. The cause is that CashPayment has not implemented process_payment().

Corrected Version

class CashPayment(Payment):

    def process_payment(self, amount):
        return f"Cash payment received: ₹{amount}"


payment = CashPayment()
print(payment.process_payment(500))

Output

Cash payment received: ₹500

12. Using Multiple Abstract Methods

An abstract base class can define multiple required operations. A concrete subclass must implement all inherited abstract methods before it can be instantiated.

Example

from abc import ABC, abstractmethod

class DataStorage(ABC):

    @abstractmethod
    def save(self, data):
        pass

    @abstractmethod
    def load(self):
        pass

    @abstractmethod
    def delete(self, key):
        pass


class FileStorage(DataStorage):

    def __init__(self):
        self.data = {}

    def save(self, data):
        self.data.update(data)

    def load(self):
        return self.data

    def delete(self, key):
        self.data.pop(key, None)


storage = FileStorage()
storage.save({"name": "Amit", "role": "Developer"})

print(storage.load())

storage.delete("role")
print(storage.load())

Output

{'name': 'Amit', 'role': 'Developer'}
{'name': 'Amit'}

The DataStorage class specifies the required storage operations. FileStorage supplies a simple in-memory implementation for demonstration. A real file-based implementation would use file operations to persist the data beyond the lifetime of the object.

13. Abstract Properties in Python

Abstract properties allow a base class to require subclasses to provide particular attributes through property access. They are useful when a value should be available consistently across different implementations.

Example

from abc import ABC, abstractmethod

class Product(ABC):

    @property
    @abstractmethod
    def price(self):
        pass


class Laptop(Product):

    def __init__(self, price):
        self._price = price

    @property
    def price(self):
        return self._price


laptop = Laptop(65000)
print(laptop.price)

Output

65000

Explanation

• @property exposes a method as an attribute.
• @abstractmethod requires a concrete implementation of the property.
• The Laptop class provides a getter that returns the stored price.
• The property can be accessed with laptop.price rather than laptop.price().

Abstract properties can also be designed with setters or deleters when subclasses must support updating or removing a value.

14. Real-World Example: Payment Processing System

Payment processing is a useful example of abstract base classes because different payment methods share a common operation but have different implementations.

Implementation

from abc import ABC, abstractmethod

class PaymentGateway(ABC):

    @abstractmethod
    def pay(self, amount):
        pass

    def receipt(self, amount):
        return f"Payment request created for ₹{amount}"


class UPI(PaymentGateway):

    def pay(self, amount):
        return f"Processing UPI payment of ₹{amount}"


class CardPayment(PaymentGateway):

    def pay(self, amount):
        return f"Processing card payment of ₹{amount}"


class WalletPayment(PaymentGateway):

    def pay(self, amount):
        return f"Processing wallet payment of ₹{amount}"


def checkout(gateway, amount):
    print(gateway.receipt(amount))
    print(gateway.pay(amount))


checkout(UPI(), 1200)
checkout(CardPayment(), 2500)
checkout(WalletPayment(), 800)

Output

Payment request created for ₹1200
Processing UPI payment of ₹1200
Payment request created for ₹2500
Processing card payment of ₹2500
Payment request created for ₹800
Processing wallet payment of ₹800

Benefits of This Design

• Every payment gateway follows the same required method contract.
• The shared receipt method is implemented only once.
• New payment types can be added without rewriting the checkout function.
• Each payment class can have its own validation and processing logic.

This example demonstrates object-oriented design only. A production payment system would also require secure gateway integrations, transaction verification, error handling, idempotency, and protection of sensitive payment information.

15. Virtual Subclasses and ABC Registration

Python allows a class to be registered as a virtual subclass of an abstract base class using the register() method. This can make issubclass() and isinstance() recognize the relationship without requiring normal inheritance.

Example

from abc import ABC

class Printable(ABC):
    pass


class Report:
    def print_report(self):
        return "Printing report"


Printable.register(Report)

report = Report()

print(issubclass(Report, Printable))
print(isinstance(report, Printable))

Output

True
True

Virtual registration does not inject methods into the registered class and does not enforce abstract method implementations. In this example, the Printable ABC has no abstract methods. Use registration when classification is needed, not as a substitute for implementation enforcement.

16. Common Errors and Troubleshooting

17. Best Practices for Abstract Base Classes and Interfaces

• Define clear contracts: Abstract methods should describe meaningful operations that every concrete subclass must support.
• Keep base classes focused: Avoid putting unrelated responsibilities into a single abstract class.
• Use descriptive names: Names such as save(), load(), and process_payment() make expected behavior clear.
• Reuse common logic: Put genuinely shared behavior in concrete methods where appropriate.
• Choose inheritance carefully: Use an ABC when a shared class relationship and enforcement are useful.
• Consider Protocol for flexible APIs: Structural typing is often preferable when classes should not depend on a particular base class.
• Do not overuse abstraction: A simple class or function may be sufficient when there is only one implementation and no meaningful extension point.
• Document method contracts: Explain accepted arguments, return values, exceptions, and expected side effects.
• Test concrete subclasses: Verify that each implementation behaves correctly, not merely that it implements the required method names.
• Follow the Liskov Substitution Principle: A subclass should be usable wherever the base abstraction is expected without breaking the program's intended behavior.

18. Abstract Base Classes and Polymorphism

Polymorphism allows different object types to be used through a common interface. Abstract base classes support polymorphism by establishing a shared contract for related classes.

Example

from abc import ABC, abstractmethod

class Shape(ABC):

    @abstractmethod
    def area(self):
        pass


class Circle(Shape):

    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2


class Rectangle(Shape):

    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width


def display_area(shape):
    print(f"Area: {shape.area():.2f}")


display_area(Circle(5))
display_area(Rectangle(4, 6))

Output

Area: 78.54
Area: 24.00

The display_area() function does not need to know whether it receives a circle or a rectangle. It calls the common area() operation, and each object supplies its own implementation.

19. Practical Exercises

Exercise 1: Vehicle Interface

Create an abstract class named Vehicle with an abstract method start(). Implement it in Car and Bike classes. Each implementation should return a different message.

Exercise 2: Employee Salary

Create an abstract class named Employee with the abstract method calculate_salary(). Implement it in FullTimeEmployee and ContractEmployee, using different salary calculations.

Exercise 3: File Exporter

Define an abstract class named Exporter with a method called export(data). Implement CSVExporter and JSONExporter classes that convert data into different formats.

Exercise 4: Notification System

Design an abstract notification service with a required send(message) method. Implement email, SMS, and push notification classes and test them through a common function.

Exercise 5: Protocol-Based Interface

Create a Loggable protocol requiring a log(message) method. Implement two unrelated classes that satisfy the protocol, then write a function that accepts either object.

20. Mini Project: Document Export System

Project Goal: Build a small document export system that uses an abstract base class to enforce a common export operation.

Project Requirements

• Create an abstract class named DocumentExporter.
• Define an abstract method named export(content).
• Create TextExporter and HTMLExporter subclasses.
• Implement a different export format in each subclass.
• Create a function that accepts a DocumentExporter object and exports the provided content.
• Test both implementations with sample text.

Sample Solution

from abc import ABC, abstractmethod
from html import escape


class DocumentExporter(ABC):

    @abstractmethod
    def export(self, content):
        pass


class TextExporter(DocumentExporter):

    def export(self, content):
        return content


class HTMLExporter(DocumentExporter):

    def export(self, content):
        return f"<p>{escape(content)}</p>"


def export_document(exporter, content):
    result = exporter.export(content)
    print(result)


text_exporter = TextExporter()
html_exporter = HTMLExporter()

export_document(text_exporter, "Welcome to Python")
export_document(html_exporter, "Welcome to Python")

Output

Welcome to Python
<p>Welcome to Python</p>

Project Learning Outcomes

• Understand how abstract methods establish implementation requirements.
• Apply inheritance and polymorphism in a practical program.
• Reuse a common function with multiple concrete implementations.
• Learn how to extend the system with additional exporters.

21. Interview Questions and Answers

Q1. What is an abstract base class in Python?

An abstract base class is a class intended to define a common contract for subclasses. It can declare abstract methods that concrete subclasses must implement before instantiation.

Q2. Which module supports abstract base classes?

Python's built-in abc module provides the ABC class, the @abstractmethod decorator, and related functionality.

Q3. Can we create an object of an abstract class?

Not while the class has unresolved abstract methods. Python raises a TypeError if instantiation is attempted.

Q4. What is the purpose of the @abstractmethod decorator?

It marks a method as abstract so that concrete subclasses are required to implement it before they can be instantiated.

Q5. Does Python support interfaces?

Python does not provide a dedicated interface keyword. Interface-like behavior can be implemented with abstract base classes, protocols, and duck typing.

Q6. What is the difference between an ABC and a Protocol?

An ABC typically uses explicit inheritance and can enforce abstract methods at instantiation. A protocol describes a required structure and supports structural typing without requiring inheritance.

Q7. Can an abstract class contain regular methods?

Yes. An abstract class can contain constructors, attributes, and concrete methods in addition to abstract methods.

Q8. Can an abstract method contain code?

Yes. An abstract method may contain an implementation. A subclass must still override it to satisfy the abstract requirement, and the subclass may call the base implementation using super().

Q9. What happens if a subclass does not implement every abstract method?

The subclass remains abstract and cannot be instantiated until all inherited abstract methods are implemented.

Q10. What is a virtual subclass?

A virtual subclass is a class registered with an ABC or recognized through its subclass hook without normal inheritance. Registration does not add methods or enforce abstract implementations.

Q11. When should we use an abstract base class?

Use an ABC when related classes must follow a common contract, and explicit inheritance or shared behavior is valuable.

Q12. When is Protocol a better choice?

Use a protocol when functions should accept different classes that provide compatible operations without requiring those classes to share a base class.

Q13. What is the relationship between abstraction and polymorphism?

Abstraction defines the expected operations, while polymorphism allows different implementations to be used through those operations.

Q14. What is the purpose of ABCMeta?

ABCMeta is the metaclass responsible for the abstract base class mechanism. In common cases, inheriting from ABC is the simpler approach.

Q15. Can a class inherit from multiple abstract base classes?

Yes. Python supports multiple inheritance, including inheritance from multiple ABCs. Developers should design the hierarchy carefully and understand the method resolution order.

22. Quick Revision Notes

• Abstraction hides unnecessary implementation details and exposes essential operations.
• An abstract base class defines a common contract for subclasses.
• Import ABC and abstractmethod from the abc module.
• Use @abstractmethod to declare required operations.
• A concrete subclass must implement all inherited abstract methods before instantiation.
• Abstract classes can contain both abstract and concrete methods.
• Python interfaces can be modeled using ABCs, protocols, or duck typing.
• Protocol supports structural typing without requiring inheritance.
• Virtual subclass registration does not enforce method implementation.
• ABCs can support polymorphism, code reuse, and extensible application design.

Key Syntax to Remember

from abc import ABC, abstractmethod

class MyInterface(ABC):

    @abstractmethod
    def perform_action(self):
        pass


class MyClass(MyInterface):

    def perform_action(self):
        return "Action completed"


obj = MyClass()
print(obj.perform_action())

23. Conclusion

Abstract base classes and interfaces are valuable tools for designing structured, reusable, and maintainable Python applications. Abstract base classes let developers define required methods and optionally provide shared behavior. Protocols offer a flexible alternative when an object only needs to support a particular set of operations, without inheriting from a common base class.

Understanding these concepts helps developers build extensible systems such as payment processors, notification services, data exporters, storage systems, and plugin architectures. Practice implementing multiple concrete classes against a common contract to strengthen your understanding of abstraction, inheritance, and polymorphism.

To continue learning Python, explore the Python Training Course at JustAcademy, visit the JustAcademy website, or register for a course demo.